home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Games / MAME / src / vidhrdw / lkage.c < prev    next >
C/C++ Source or Header  |  2000-04-04  |  6KB  |  241 lines
  1. #include "driver.h"
  2. #include "vidhrdw/generic.h"
  3.  
  4. unsigned char *lkage_scroll, *lkage_vreg;
  5. static unsigned char bg_tile_bank, fg_tile_bank;
  6.  
  7. /*
  8.     lkage_scroll[0x00]: unknown (always 0xf7)
  9.     lkage_scroll[0x01]: unknown (always 0x00)
  10.     lkage_scroll[0x02]: foreground layer horizontal scroll
  11.     lkage_scroll[0x03]: foreground layer vertical scroll
  12.     lkage_scroll[0x04]: background layer horizontal scroll
  13.     lkage_scroll[0x05]: background layer vertical scroll
  14.  
  15.     lkage_vreg[0x00]:
  16.         0x04: tile bank select
  17.  
  18.     lkage_vreg[0x01]:
  19.         0xf0: background, foreground palette select
  20.         0x08: tile bank select
  21.         0x07: text layer palette select
  22. */
  23.  
  24. struct tilemap *bg_tilemap, *fg_tilemap, *tx_tilemap;
  25.  
  26. WRITE_HANDLER( lkage_videoram_w )
  27. {
  28.     if( videoram[offset]!=data )
  29.     {
  30.         videoram[offset] = data;
  31.  
  32.         switch( offset/0x400 )
  33.         {
  34.             case 0:
  35.             tilemap_mark_tile_dirty(tx_tilemap,offset & 0x3ff);
  36.             break;
  37.  
  38.             case 1:
  39.             tilemap_mark_tile_dirty(fg_tilemap,offset & 0x3ff);
  40.             break;
  41.  
  42.             case 2:
  43.             tilemap_mark_tile_dirty(bg_tilemap,offset & 0x3ff);
  44.             break;
  45.         }
  46.     }
  47. }
  48.  
  49. static void get_bg_tile_info(int tile_index)
  50. {
  51.     SET_TILE_INFO(bg_tile_bank?2:1,videoram[tile_index + 0x800],0);
  52. }
  53.  
  54. static void get_fg_tile_info(int tile_index)
  55. {
  56.     SET_TILE_INFO(fg_tile_bank?1:0,videoram[tile_index + 0x400],1);
  57. }
  58.  
  59. static void get_tx_tile_info(int tile_index)
  60. {
  61.     SET_TILE_INFO(0,videoram[tile_index],2);
  62. }
  63.  
  64. int lkage_vh_start(void)
  65. {
  66.     bg_tile_bank = fg_tile_bank = 0;
  67.  
  68.     bg_tilemap = tilemap_create(get_bg_tile_info,tilemap_scan_rows,TILEMAP_OPAQUE,     8,8,32,32);
  69.     fg_tilemap = tilemap_create(get_fg_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,32,32);
  70.     tx_tilemap = tilemap_create(get_tx_tile_info,tilemap_scan_rows,TILEMAP_TRANSPARENT,8,8,32,32);
  71.  
  72.     if (!bg_tilemap || !fg_tilemap || !tx_tilemap)
  73.         return 1;
  74.  
  75.     fg_tilemap->transparent_pen = 0;
  76.     tx_tilemap->transparent_pen = 0;
  77.     return 0;
  78. }
  79.  
  80. static void draw_sprites( struct osd_bitmap *bitmap, int priority )
  81. {
  82.     const struct rectangle *clip = &Machine->drv->visible_area;
  83.     const unsigned char *finish = spriteram;
  84.     const unsigned char *source = spriteram+0x60-4;
  85.     const struct GfxElement *gfx = Machine->gfx[3];
  86.  
  87.     while( source>=finish )
  88.     {
  89.         int attributes = source[2];
  90.         /*
  91.             bit 0: horizontal flip
  92.             bit 1: vertical flip
  93.             bit 2: bank select
  94.             bit 3: sprite size
  95.             bit 4..6: color
  96.             bit 7: priority
  97.         */
  98.  
  99.         if( (attributes>>7) == priority )
  100.         {
  101.             int sy = 240-source[1];
  102.             int sx = source[0] - 16;
  103.             int color = (attributes>>4)&7;
  104.  
  105.             int sprite_number = source[3];
  106.             if( attributes&0x04 )
  107.                 sprite_number += 128;
  108.             else
  109.                 sprite_number += 256;
  110.  
  111.             if( sprite_number!=256 )
  112.             { /* enable */
  113.                 if( attributes&0x02 )
  114.                 { /* vertical flip */
  115.                     if( attributes&0x08 )
  116.                     { /* tall sprite */
  117.                         sy -= 16;
  118.                         drawgfx( bitmap,gfx,
  119.                             sprite_number^1,
  120.                             color,
  121.                             attributes&1,1, /* flip */
  122.                             sx,sy+16,
  123.                             clip,
  124.                             TRANSPARENCY_PEN,0 );
  125.                     }
  126.                     drawgfx( bitmap,gfx,
  127.                         sprite_number,
  128.                         color,
  129.                         attributes&1,1, /* flip */
  130.                         sx,sy,
  131.                         clip,
  132.                         TRANSPARENCY_PEN,0 );
  133.                 }
  134.                 else
  135.                 {
  136.                     if( attributes&0x08 )
  137.                     { /* tall sprite */
  138.                         drawgfx( bitmap,gfx,
  139.                             sprite_number^1,
  140.                             color,
  141.                             attributes&1,0, /* flip */
  142.                             sx,sy-16,
  143.                             clip,
  144.                             TRANSPARENCY_PEN,0 );
  145.                     }
  146.                     drawgfx( bitmap,gfx,
  147.                         sprite_number,
  148.                         color,
  149.                         attributes&1,0, /* flip */
  150.                         sx,sy,
  151.                         clip,
  152.                         TRANSPARENCY_PEN,0 );
  153.                 }
  154.             }
  155.         }
  156.         source-=4;
  157.     }
  158. }
  159.  
  160. void lkage_set_palette_row( int virtual_row, int logical_row, int len )
  161. {
  162.     unsigned char *source = &paletteram[logical_row*32];
  163.     int indx = virtual_row*16;
  164.     while( len-- )
  165.     {
  166.         unsigned char greenblue = *source++;
  167.         unsigned char red = *source++;
  168.         palette_change_color( indx++,
  169.             (red&0xf)*0x11,
  170.             (greenblue>>4)*0x11,
  171.             (greenblue&0xf)*0x11
  172.         );
  173.     }
  174. }
  175.  
  176. void lkage_vh_screenrefresh(struct osd_bitmap *bitmap,int full_refresh)
  177. {
  178.     if( bg_tile_bank != (lkage_vreg[0x01]&0x08) )
  179.     {
  180.         bg_tile_bank = lkage_vreg[0x01]&0x08;
  181.         tilemap_mark_all_tiles_dirty( bg_tilemap );
  182.     }
  183.  
  184.     if( fg_tile_bank != (lkage_vreg[0x00]&0x04) )
  185.     {
  186.         fg_tile_bank = lkage_vreg[0x00]&0x04;
  187.         tilemap_mark_all_tiles_dirty( fg_tilemap );
  188.     }
  189.  
  190.     {
  191.         lkage_set_palette_row( 0x0, 0x00, 16*8 ); /* sprite colors */
  192.         lkage_set_palette_row( 0x8, 0x30 + (lkage_vreg[1]>>4),16 ); /* bg colors */
  193.         lkage_set_palette_row( 0x9, 0x20 + (lkage_vreg[1]>>4),16 ); /* fg colors */
  194.         lkage_set_palette_row( 0xa, 0x11, 16 ); /* text colors */
  195.     }
  196.  
  197.     tilemap_set_scrollx( fg_tilemap,0, lkage_scroll[2]+8 );
  198.     tilemap_set_scrolly( fg_tilemap,0, lkage_scroll[3] );
  199.     tilemap_set_scrollx( bg_tilemap,0, lkage_scroll[4]+8 );
  200.     tilemap_set_scrolly( bg_tilemap,0, lkage_scroll[5] );
  201.  
  202.     tilemap_update( ALL_TILEMAPS );
  203.     if (palette_recalc())  tilemap_mark_all_pixels_dirty(ALL_TILEMAPS);
  204.     tilemap_render( ALL_TILEMAPS );
  205.  
  206.     /*
  207.         A register exists which is normally 0xf3,
  208.         but goes to 0x13 inbetween stages (while the backgrounds are
  209.         are being redrawn).  Its bits are probably used to enable
  210.         individual layers, but we have no way of knowing the mapping.
  211.     */
  212.     if( lkage_vreg[2]==0xf3 )
  213.     {
  214.         tilemap_draw( bitmap,bg_tilemap,0 );
  215.         draw_sprites( bitmap, 1 );
  216.         tilemap_draw( bitmap,fg_tilemap,0 );
  217.         draw_sprites( bitmap, 0 );
  218.         tilemap_draw( bitmap,tx_tilemap,0 );
  219.     }
  220.     else
  221.     {
  222.         tilemap_draw( bitmap,tx_tilemap,TILEMAP_IGNORE_TRANSPARENCY );
  223.     }
  224.  
  225.  
  226. #if 0
  227.     drawgfx( bitmap,Machine->uifont,
  228.         "0123456789abcdef"[lkage_vreg[1]>>4],
  229.         0,0,0,
  230.         16,32,
  231.         0,
  232.         TRANSPARENCY_NONE,0 );
  233.     drawgfx( bitmap,Machine->uifont,
  234.         "0123456789abcdef"[lkage_vreg[1]&0xf],
  235.         0,0,0,
  236.         16+6,32,
  237.         0,
  238.         TRANSPARENCY_NONE,0 );
  239. #endif
  240. }
  241.